{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas 获取排序顺序 - argsort() 和索引操作详解\n\n本教程详细介绍如何获取数据排序后的索引顺序，而不是排序后的数据本身。\n\n## 目录\n1. argsort() 基础用法\n2. 获取排序索引的不同方法\n3. 排序索引的应用场景\n4. 与 rank() 和 sort_values() 的区别\n5. 多列排序索引\n6. 实际应用案例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 导入库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\nimport numpy as np\nimport warnings\nwarnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. argsort() 基础用法\n\n### 方法说明\n\n`argsort()` 方法返回排序后的索引位置，而不是排序后的值。\n\n**语法:**\n```python\ns.argsort()  # Series 的 argsort\ndf['column'].argsort()  # DataFrame 列的 argsort\n```\n\n**特点:**\n- ✅ 返回排序索引，不是排序后的值\n- ✅ 默认升序排序\n- ✅ 基于 NumPy 实现，性能较好\n- ✅ 可以用于重新排列其他数组\n\n**适用场景:** 需要知道排序顺序，用于排列其他相关数据时\n\n**与其他方法的区别:**\n- `argsort()`: 返回排序索引\n- `sort_values()`: 返回排序后的数据\n- `rank()`: 返回每个元素的排名"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例1: 创建示例数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建学生成绩数据\ndf = pd.DataFrame({\n    '姓名': ['张三', '李四', '王五', '赵六', '孙七'],\n    '数学': [85, 92, 78, 96, 88],\n    '英语': [90, 85, 95, 82, 91]\n})\n\nprint(\"原始数据:\")\nprint(df)\nprint(\"\\n数学成绩:\", df['数学'].tolist())\nprint(\"原始索引:\", df.index.tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例2: argsort() 基础用法\n\n获取数学成绩的排序索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 获取数学成绩的排序索引（升序）\nsort_indices = df['数学'].argsort()\nprint(\"数学成绩排序索引（升序）:\")\nprint(sort_indices)\nprint(\"\\n解释：索引含义\")\nfor i, idx in enumerate(sort_indices):\n    print(f\"第{i+1}名: 索引{idx} -> {df.loc[idx, '姓名']} ({df.loc[idx, '数学']}分)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例3: 降序排序索引\n\n获取降序排序的索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 降序排序索引（分数从高到低）\ndesc_indices = df['数学'].argsort()[::-1]\nprint(\"数学成绩排序索引（降序）:\")\nprint(desc_indices)\nprint(\"\\n解释：索引含义\")\nfor i, idx in enumerate(desc_indices):\n    print(f\"第{i+1}名: 索引{idx} -> {df.loc[idx, '姓名']} ({df.loc[idx, '数学']}分)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例4: 使用排序索引重新排列数据\n\n使用获取的索引来排列整个 DataFrame。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用排序索引重新排列整个 DataFrame\nsorted_df = df.iloc[desc_indices]\nprint(\"按数学成绩降序排列的完整数据:\")\nprint(sorted_df)\n\n# 验证：这等同于 sort_values()\nsorted_df_verify = df.sort_values('数学', ascending=False)\nprint(\"\\n使用 sort_values() 的结果（验证）:\")\nprint(sorted_df_verify)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 获取排序索引的不同方法\n\n### 方法对比\n\n有多种方法可以获取排序后的索引顺序。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 方法1: argsort() - 直接获取排序索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.Series([85, 92, 78, 96, 88], name='成绩')\nprint(\"原始数据:\")\nprint(data)\n\n# 方法1: argsort()\nindices_argsort = data.argsort()[::-1]  # 降序\nprint(\"\\n方法1 - argsort() 结果:\")\nprint(indices_argsort)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 方法2: sort_values() 后获取索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 方法2: sort_values() 后获取索引\nsorted_series = data.sort_values(ascending=False)\nindices_sort = sorted_series.index\nprint(\"方法2 - sort_values() 后的索引:\")\nprint(indices_sort)\n\n# 验证两种方法结果相同\nprint(\"\\n两种方法结果是否相同:\", indices_argsort.equals(indices_sort))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 方法3: numpy.argsort() - 更底层的方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 方法3: numpy.argsort()\nindices_numpy = np.argsort(data.values)[::-1]  # 降序\nprint(\"方法3 - numpy.argsort() 结果:\")\nprint(indices_numpy)\n\n# 注意：numpy 返回的是 numpy 数组，pandas 返回的是 Index 对象\nprint(\"\\n数据类型对比:\")\nprint(f\"pandas argsort: {type(indices_argsort)}\")\nprint(f\"numpy argsort:  {type(indices_numpy)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 性能对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n\n# 创建大数据集进行性能测试\nlarge_data = pd.Series(np.random.randint(1, 1000, 10000))\n\n# 测试 pandas argsort\nstart = time.time()\nresult1 = large_data.argsort()\ntime_pandas = time.time() - start\n\n# 测试 numpy argsort\nstart = time.time()\nresult2 = np.argsort(large_data.values)\ntime_numpy = time.time() - start\n\n# 测试 sort_values + index\nstart = time.time()\nresult3 = large_data.sort_values().index\ntime_sort = time.time() - start\n\nprint(\"性能对比（10000个元素）:\")\nprint(f\"pandas argsort():     {time_pandas:.6f} 秒\")\nprint(f\"numpy argsort():      {time_numpy:.6f} 秒\")\nprint(f\"sort_values().index:  {time_sort:.6f} 秒\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 排序索引的应用场景\n\n### 场景1: 同步排列多个相关数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 学生信息分散在多个数组中\nnames = ['张三', '李四', '王五', '赵六', '孙七']\nmath_scores = [85, 92, 78, 96, 88]\nenglish_scores = [90, 85, 95, 82, 91]\nages = [18, 19, 18, 20, 19]\n\nprint(\"原始数据:\")\nprint(f\"姓名: {names}\")\nprint(f\"数学: {math_scores}\")\nprint(f\"英语: {english_scores}\")\nprint(f\"年龄: {ages}\")\n\n# 按数学成绩排序\nmath_series = pd.Series(math_scores)\nsort_indices = math_series.argsort()[::-1]\n\nprint(f\"\\n排序索引: {sort_indices.tolist()}\")\n\n# 使用索引同步排列所有数组\nsorted_names = [names[i] for i in sort_indices]\nsorted_math = [math_scores[i] for i in sort_indices]\nsorted_english = [english_scores[i] for i in sort_indices]\nsorted_ages = [ages[i] for i in sort_indices]\n\nprint(\"\\n按数学成绩排序后:\")\nprint(f\"姓名: {sorted_names}\")\nprint(f\"数学: {sorted_math}\")\nprint(f\"英语: {sorted_english}\")\nprint(f\"年龄: {sorted_ages}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 场景2: 获取排名信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 获取前N名的详细信息\ndf = pd.DataFrame({\n    '产品': ['产品A', '产品B', '产品C', '产品D', '产品E'],\n    '销售额': [150000, 120000, 180000, 90000, 160000],\n    '利润': [30000, 36000, 25000, 18000, 40000]\n})\n\nprint(\"产品销售数据:\")\nprint(df)\n\n# 按销售额获取排序索引\nsales_indices = df['销售额'].argsort()[::-1]\nprint(f\"\\n销售额排序索引: {sales_indices.tolist()}\")\n\n# 获取前3名产品的详细信息\ntop3_indices = sales_indices[:3]\nprint(\"\\n销售额前3名:\")\nfor i, idx in enumerate(top3_indices):\n    product = df.loc[idx, '产品']\n    sales = df.loc[idx, '销售额']\n    profit = df.loc[idx, '利润']\n    print(f\"第{i+1}名: {product} - 销售额{sales:,}, 利润{profit:,}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 场景3: 自定义排序逻辑"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 复杂的排序逻辑：先按销售额，再按利润率\ndf['利润率'] = df['利润'] / df['销售额']\nprint(\"添加利润率后的数据:\")\nprint(df[['产品', '销售额', '利润', '利润率']])\n\n# 创建组合排序键\n# 销售额标准化到0-1，利润率也标准化到0-1，然后加权\nsales_norm = (df['销售额'] - df['销售额'].min()) / (df['销售额'].max() - df['销售额'].min())\nprofit_rate_norm = (df['利润率'] - df['利润率'].min()) / (df['利润率'].max() - df['利润率'].min())\n\n# 组合得分：销售额权重0.6，利润率权重0.4\ncomposite_score = sales_norm * 0.6 + profit_rate_norm * 0.4\nprint(\"\\n组合得分:\")\nprint(composite_score)\n\n# 获取组合排序索引\ncomposite_indices = composite_score.argsort()[::-1]\nprint(\"\\n综合排名:\")\nfor i, idx in enumerate(composite_indices):\n    product = df.loc[idx, '产品']\n    score = composite_score.iloc[idx]\n    print(f\"第{i+1}名: {product} - 综合得分{score:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 与 rank() 和 sort_values() 的区别\n\n### 详细对比三种方法的差异"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 对比示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建示例数据\ndata = pd.Series([85, 92, 78, 96, 88], \n                index=['A', 'B', 'C', 'D', 'E'], \n                name='分数')\nprint(\"原始数据:\")\nprint(data)\n\nprint(\"\\n\" + \"=\"*50)\n\n# 1. argsort() - 返回排序索引\nsort_indices = data.argsort()[::-1]  # 降序\nprint(\"1. argsort() - 排序索引:\")\nprint(sort_indices)\nprint(\"含义：按分数从高到低的原始索引顺序\")\n\nprint(\"\\n\" + \"=\"*50)\n\n# 2. sort_values() - 返回排序后的数据\nsorted_data = data.sort_values(ascending=False)\nprint(\"2. sort_values() - 排序后的数据:\")\nprint(sorted_data)\nprint(\"含义：按分数从高到低排列的实际数据\")\n\nprint(\"\\n\" + \"=\"*50)\n\n# 3. rank() - 返回排名\nranks = data.rank(ascending=False)\nprint(\"3. rank() - 排名:\")\nprint(ranks)\nprint(\"含义：每个元素在排序中的排名位置\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 实际应用对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"实际应用场景对比:\")\nprint()\nprint(\"🎯 argsort() 适用场景:\")\nprint(\"  ✅ 需要知道排序顺序，用于排列其他数据\")\nprint(\"  ✅ 获取前N名的原始索引\")\nprint(\"  ✅ 同步排列多个相关数组\")\nprint(\"  ✅ 自定义复杂排序逻辑\")\nprint()\nprint(\"📊 sort_values() 适用场景:\")\nprint(\"  ✅ 需要重新排列数据进行展示\")\nprint(\"  ✅ 数据分析和可视化\")\nprint(\"  ✅ 获取排序后的实际值\")\nprint()\nprint(\"🏆 rank() 适用场景:\")\nprint(\"  ✅ 计算排名、百分位\")\nprint(\"  ✅ 绩效评估、成绩分析\")\nprint(\"  ✅ 保持原始数据结构的排名信息\")\n\n# 具体示例\nprint(\"\\n\" + \"=\"*50)\nprint(\"具体示例：\")\n\n# 假设我们有学生成绩，想要：\nscores = pd.Series([85, 92, 78, 96, 88], \n                  index=['张三', '李四', '王五', '赵六', '孙七'])\n\n# 1. 获取前3名学生的姓名（用argsort）\ntop3_indices = scores.argsort()[::-1][:3]\ntop3_names = [scores.index[i] for i in top3_indices]\nprint(f\"前3名学生姓名: {top3_names}\")\n\n# 2. 显示排序后的成绩单（用sort_values）\nsorted_scores = scores.sort_values(ascending=False)\nprint(\"\\n排序后的成绩单:\")\nprint(sorted_scores)\n\n# 3. 给每个学生标注排名（用rank）\nstudent_ranks = scores.rank(ascending=False)\nprint(\"\\n学生排名:\")\nprint(student_ranks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 多列排序索引\n\n### 处理多列排序的索引获取"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 方法说明\n\n对于多列排序，需要组合使用不同的方法。\n\n**策略:**\n1. 使用 sort_values() 多列排序后获取索引\n2. 创建组合排序键后使用 argsort()\n3. 逐级排序\n\n**适用场景:** 复杂的多条件排序需求"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例1: 多列排序索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建学生数据\ndf_multi = pd.DataFrame({\n    '姓名': ['张三', '李四', '王五', '赵六', '孙七', '周八'],\n    '班级': ['A', 'B', 'A', 'B', 'A', 'B'],\n    '总分': [285, 290, 285, 275, 290, 280],\n    '数学': [95, 98, 92, 88, 96, 90]\n})\n\nprint(\"学生数据:\")\nprint(df_multi)\n\n# 方法1: 使用 sort_values() 多列排序后获取索引\nmulti_sort_indices = df_multi.sort_values(['班级', '总分'], \n                                         ascending=[True, False]).index\nprint(\"\\n多列排序索引（先按班级，再按总分降序）:\")\nprint(multi_sort_indices.tolist())\n\n# 使用索引重新排列数据\nsorted_multi = df_multi.loc[multi_sort_indices]\nprint(\"\\n排序后的数据:\")\nprint(sorted_multi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例2: 创建组合排序键"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 方法2: 创建组合排序键\n# 假设我们要按：班级(A=1, B=2) + 总分(降序)\nclass_map = {'A': 1, 'B': 2}\ndf_multi['班级数值'] = df_multi['班级'].map(class_map)\n\n# 创建组合键：班级*1000 - 总分（这样A班在前，总分高的在前）\ndf_multi['组合键'] = df_multi['班级数值'] * 1000 - df_multi['总分']\n\nprint(\"添加组合键后的数据:\")\nprint(df_multi[['姓名', '班级', '总分', '组合键']])\n\n# 使用 argsort() 排序\ncomposite_indices = df_multi['组合键'].argsort()\nprint(\"\\n组合键排序索引:\")\nprint(composite_indices.tolist())\n\n# 查看排序结果\nresult = df_multi.iloc[composite_indices]\nprint(\"\\n按组合键排序的结果:\")\nprint(result[['姓名', '班级', '总分']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 实际应用案例\n\n### 案例1: 电商产品推荐排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 电商产品数据\nproducts = pd.DataFrame({\n    '产品ID': ['P001', 'P002', 'P003', 'P004', 'P005'],\n    '产品名': ['手机A', '手机B', '手机C', '手机D', '手机E'],\n    '价格': [3999, 2999, 4999, 1999, 3499],\n    '评分': [4.5, 4.2, 4.8, 3.9, 4.6],\n    '销量': [1200, 800, 600, 2000, 900],\n    '库存': [50, 20, 5, 100, 30]\n})\n\nprint(\"产品数据:\")\nprint(products)\n\n# 推荐算法：综合考虑评分、销量、库存\n# 评分权重40%，销量权重30%，库存权重20%，价格权重10%（价格越低越好）\n\n# 标准化各指标到0-1\nrating_norm = (products['评分'] - products['评分'].min()) / (products['评分'].max() - products['评分'].min())\nsales_norm = (products['销量'] - products['销量'].min()) / (products['销量'].max() - products['销量'].min())\nstock_norm = (products['库存'] - products['库存'].min()) / (products['库存'].max() - products['库存'].min())\nprice_norm = 1 - (products['价格'] - products['价格'].min()) / (products['价格'].max() - products['价格'].min())  # 价格越低越好\n\n# 计算推荐得分\nrecommend_score = (rating_norm * 0.4 + \n                  sales_norm * 0.3 + \n                  stock_norm * 0.2 + \n                  price_norm * 0.1)\n\nproducts['推荐得分'] = recommend_score\n\n# 获取推荐排序索引\nrecommend_indices = recommend_score.argsort()[::-1]\n\nprint(\"\\n产品推荐排序:\")\nfor i, idx in enumerate(recommend_indices):\n    product = products.loc[idx]\n    print(f\"第{i+1}名: {product['产品名']} - 得分{product['推荐得分']:.3f}\")\n    print(f\"       价格{product['价格']}, 评分{product['评分']}, 销量{product['销量']}, 库存{product['库存']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 案例2: 员工绩效排序系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 员工绩效数据\nemployees = pd.DataFrame({\n    '员工ID': ['E001', 'E002', 'E003', 'E004', 'E005'],\n    '姓名': ['张三', '李四', '王五', '赵六', '孙七'],\n    '部门': ['销售', '技术', '销售', '技术', '销售'],\n    '工作质量': [85, 92, 78, 96, 88],\n    '工作效率': [90, 85, 95, 82, 91],\n    '团队协作': [88, 90, 85, 94, 87],\n    '创新能力': [75, 95, 70, 90, 80]\n})\n\nprint(\"员工绩效数据:\")\nprint(employees)\n\n# 不同部门的权重不同\ndef calculate_performance_score(row):\n    if row['部门'] == '销售':\n        # 销售部门：工作质量30%，效率40%，协作20%，创新10%\n        return (row['工作质量'] * 0.3 + \n                row['工作效率'] * 0.4 + \n                row['团队协作'] * 0.2 + \n                row['创新能力'] * 0.1)\n    else:  # 技术部门\n        # 技术部门：工作质量25%，效率25%，协作20%，创新30%\n        return (row['工作质量'] * 0.25 + \n                row['工作效率'] * 0.25 + \n                row['团队协作'] * 0.2 + \n                row['创新能力'] * 0.3)\n\nemployees['综合得分'] = employees.apply(calculate_performance_score, axis=1)\n\n# 分部门排序\nsales_employees = employees[employees['部门'] == '销售']\ntech_employees = employees[employees['部门'] == '技术']\n\nprint(\"\\n销售部门排名:\")\nsales_indices = sales_employees['综合得分'].argsort()[::-1]\nfor i, idx in enumerate(sales_indices):\n    emp = sales_employees.iloc[idx]\n    print(f\"第{i+1}名: {emp['姓名']} - 得分{emp['综合得分']:.1f}\")\n\nprint(\"\\n技术部门排名:\")\ntech_indices = tech_employees['综合得分'].argsort()[::-1]\nfor i, idx in enumerate(tech_indices):\n    emp = tech_employees.iloc[idx]\n    print(f\"第{i+1}名: {emp['姓名']} - 得分{emp['综合得分']:.1f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n\n### 获取排序顺序的方法对比\n\n| 方法 | 返回内容 | 性能 | 适用场景 |\n|------|---------|------|----------|\n| `argsort()` | 排序索引 | 快 | 需要排序顺序，同步排列多个数组 |\n| `sort_values().index` | 排序索引 | 中等 | 复杂排序后获取索引 |\n| `numpy.argsort()` | 排序索引 | 最快 | 纯数值计算，性能要求高 |\n\n### 与其他排序方法的区别\n\n| 方法 | 返回内容 | 保持原结构 | 主要用途 |\n|------|---------|-----------|----------|\n| `argsort()` | 排序索引 | ❌ | 获取排序顺序 |\n| `sort_values()` | 排序后数据 | ❌ | 重新排列数据 |\n| `rank()` | 排名数字 | ✅ | 计算排名位置 |\n\n### 关键要点\n\n1. **argsort() 返回索引**: 告诉你排序后的顺序，不是排序后的值\n2. **索引从小到大**: argsort() 默认升序，用 [::-1] 实现降序\n3. **同步排列**: 可以用排序索引同步排列多个相关数组\n4. **多列排序**: 需要组合使用或创建组合排序键\n5. **性能考虑**: numpy.argsort() 最快，pandas.argsort() 功能更丰富\n6. **实际应用**: 推荐系统、排名系统、绩效评估等\n\n### 最佳实践\n\n```python\n# ✅ 推荐用法\nindices = df['column'].argsort()[::-1]  # 降序索引\nsorted_df = df.iloc[indices]  # 使用索引排列数据\n\n# 🎯 场景选择\n# 需要排序顺序 → argsort()\n# 需要排序数据 → sort_values()\n# 需要排名信息 → rank()\n# 多数组同步 → argsort() + 索引\n```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}